//+------------------------------------------------------------------+
//|                                                      WinBase.mqh |
//|                             Copyright 2000-2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#include <WinAPI/windef.h>
#include <WinAPI/winnt.h>
#include <WinAPI/fileapi.h>

// 路径最大长度
#define OFS_MAXPATHNAME            128
// GUID长度
#define HW_PROFILE_GUIDLEN         39
// 配置文件最大长度
#define MAX_PROFILE_LEN            80
// 重启命令最大长度
#define RESTART_MAX_CMD_LINE       1024

// 文件复制阶段枚举
enum COPYFILE2_COPY_PHASE
{
    COPYFILE2_PHASE_NONE=0,               // 无阶段
    COPYFILE2_PHASE_PREPARE_SOURCE,        // 准备源文件
    COPYFILE2_PHASE_PREPARE_DEST,           // 准备目标文件
    COPYFILE2_PHASE_READ_SOURCE,            // 读取源文件
    COPYFILE2_PHASE_WRITE_DESTINATION,      // 写入目标文件
    COPYFILE2_PHASE_SERVER_COPY,            // 服务器复制
    COPYFILE2_PHASE_NAMEGRAFT_COPY,         // 名称移植复制
    COPYFILE2_PHASE_MAX                     // 最大值
};

// 复制文件消息动作枚举
enum COPYFILE2_MESSAGE_ACTION
{
    COPYFILE2_PROGRESS_CONTINUE=0,         // 继续复制
    COPYFILE2_PROGRESS_CANCEL,             // 取消复制
    COPYFILE2_PROGRESS_STOP,               // 停止复制
    COPYFILE2_PROGRESS_QUIET,              // 静默模式
    COPYFILE2_PROGRESS_PAUSE               // 暂停复制
};

// 复制文件消息类型枚举
enum COPYFILE2_MESSAGE_TYPE
{
    COPYFILE2_CALLBACK_NONE=0,             // 无回调
    COPYFILE2_CALLBACK_CHUNK_STARTED,      // 块开始
    COPYFILE2_CALLBACK_CHUNK_FINISHED,     // 块完成
    COPYFILE2_CALLBACK_STREAM_STARTED,     // 流开始
    COPYFILE2_CALLBACK_STREAM_FINISHED,    // 流完成
    COPYFILE2_CALLBACK_POLL_CONTINUE,      // 轮询继续
    COPYFILE2_CALLBACK_ERROR,              // 错误回调
    COPYFILE2_CALLBACK_MAX                 // 最大值
};

// DEP系统策略类型枚举
enum DEP_SYSTEM_POLICY_TYPE
{
    DEPPolicyAlwaysOff=0,                  // 始终关闭
    DEPPolicyAlwaysOn,                     // 始终开启
    DEPPolicyOptIn,                        // 选择加入
    DEPPolicyOptOut,                       // 选择退出
    DEPTotalPolicyCount                    // 策略总数
};

// 文件ID类型枚举
enum FILE_ID_TYPE
{
    FileIdType,                            // 文件ID类型
    ObjectIdType,                          // 对象ID类型
    ExtendedFileIdType,                   // 扩展文件ID类型
    MaximumFileIdType                     // 最大文件ID类型
};

// IO优先级提示枚举
enum PRIORITY_HINT
{
    IoPriorityHintVeryLow=0,              // 非常低优先级
    IoPriorityHintLow,                     // 低优先级
    IoPriorityHintNormal,                  // 正常优先级
    MaximumIoPriorityHintType              // 最大优先级类型
};

// 进程线程属性编号枚举
enum PROC_THREAD_ATTRIBUTE_NUM
{
    ProcThreadAttributeParentProcess=0,    // 父进程属性
    ProcThreadAttributeHandleList=2,       // 句柄列表属性
    ProcThreadAttributeGroupAffinity=3,     // 组关联性属性
    ProcThreadAttributePreferredNode=4,     // 首选节点属性
    ProcThreadAttributeIdealProcessor=5,    // 理想处理器属性
    ProcThreadAttributeUmsThread=6,         // UMS线程属性
    ProcThreadAttributeMitigationPolicy=7,  // 缓解策略属性
    ProcThreadAttributeSecurityCapabilities=9, // 安全能力属性
    ProcThreadAttributeProtectionLevel=11,  // 保护级别属性
    ProcThreadAttributeJobList=13,          // 作业列表属性
    ProcThreadAttributeChildProcessPolicy=14, // 子进程策略属性
    ProcThreadAttributeAllApplicationPackagesPolicy=15, // 所有应用包策略属性
    ProcThreadAttributeWin32kFilter=16,     // Win32k过滤器属性
    ProcThreadAttributeSafeOpenPromptOriginClaim=17, // 安全打开提示来源声明属性
    ProcThreadAttributeDesktopAppPolicy=18  // 桌面应用策略属性
};

// 激活上下文键控数据程序集元数据结构
struct ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA
{
    PVOID             lpInformation;        // 信息指针
    PVOID             lpSectionBase;        // 段基址指针
    uint              ulSectionLength;       // 段长度
    PVOID             lpSectionGlobalDataBase; // 段全局数据基址指针
    uint              ulSectionGlobalDataLength; // 段全局数据长度
};

// 激活上下文键控数据结构
struct ACTCTX_SECTION_KEYED_DATA
{
    uint              cbSize;               // 结构大小
    uint              ulDataFormatVersion;   // 数据格式版本
    PVOID             lpData;                // 数据指针
    uint              ulLength;               // 数据长度
    PVOID             lpSectionGlobalData;    // 段全局数据指针
    uint              ulSectionGlobalDataLength; // 段全局数据长度
    PVOID             lpSectionBase;         // 段基址指针
    uint              ulSectionTotalLength;   // 段总长度
    HANDLE            hActCtx;               // 激活上下文句柄
    uint              ulAssemblyRosterIndex;  // 程序集花名册索引
    uint              ulFlags;               // 标志位
    ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA AssemblyMetadata; // 程序集元数据
};

// 激活上下文键控数据结构(旧版)
struct ACTCTX_SECTION_KEYED_DATA_2600
{
    uint              cbSize;               // 结构大小
    uint              ulDataFormatVersion;   // 数据格式版本
    PVOID             lpData;                // 数据指针
    uint              ulLength;               // 数据长度
    PVOID             lpSectionGlobalData;    // 段全局数据指针
    uint              ulSectionGlobalDataLength; // 段全局数据长度
    PVOID             lpSectionBase;         // 段基址指针
    uint              ulSectionTotalLength;   // 段总长度
    HANDLE            hActCtx;               // 激活上下文句柄
    uint              ulAssemblyRosterIndex;  // 程序集花名册索引
};

// 激活上下文结构
struct ACTCTXW
{
    uint              cbSize;               // 结构大小
    uint              dwFlags;              // 标志位
    PVOID             lpSource;             // 源路径指针
    ushort            wProcessorArchitecture; // 处理器架构
    ushort            wLangId;              // 语言ID
    PVOID             lpAssemblyDirectory;  // 程序集目录指针
    PVOID             lpResourceName;        // 资源名称指针
    PVOID             lpApplicationName;     // 应用程序名称指针
    HANDLE            hModule;              // 模块句柄
};

// 激活上下文基本信息结构
struct ACTIVATION_CONTEXT_BASIC_INFORMATION
{
    HANDLE            hActCtx;              // 激活上下文句柄
    uint              dwFlags;              // 标志位
};

// 设备控制块结构
struct DCB
{
    uint              DCBlength;            // 结构大小
    uint              BaudRate;             // 波特率
    uint              Flags;                // 标志位
    ushort            wReserved;            // 保留字段
    ushort            XonLim;               // XON限制
    ushort            XoffLim;              // XOFF限制
    uchar             ByteSize;             // 字节大小
    uchar             Parity;               // 奇偶校验
    uchar             StopBits;             // 停止位
    char              XonChar;              // XON字符
    char              XoffChar;             // XOFF字符
    char              ErrorChar;            // 错误字符
    char              EofChar;              // 结束字符
    char              EvtChar;              // 事件字符
    ushort            wReserved1;           // 保留字段1
};

// 通信配置结构
struct COMMCONFIG
{
    uint              dwSize;               // 结构大小
    ushort            wVersion;             // 版本号
    ushort            wReserved;            // 保留字段
    DCB               dcb;                  // 设备控制块
    uint              dwProviderSubType;    // 提供者子类型
    uint              dwProviderOffset;     // 提供者偏移
    uint              dwProviderSize;       // 提供者大小
    short             wcProviderData[2];    // 提供者数据
};

// 通信属性结构
struct COMMPROP
{
    ushort            wPacketLength;        // 包长度
    ushort            wPacketVersion;       // 包版本
    uint              dwServiceMask;        // 服务掩码
    uint              dwReserved1;          // 保留字段1
    uint              dwMaxTxQueue;         // 最大发送队列
    uint              dwMaxRxQueue;         // 最大接收队列
    uint              dwMaxBaud;            // 最大波特率
    uint              dwProvSubType;        // 提供者子类型
    uint              dwProvCapabilities;   // 提供者能力
    uint              dwSettableParams;     // 可设置参数
    uint              dwSettableBaud;       // 可设置波特率
    ushort            wSettableData;        // 可设置数据
    ushort            wSettableStopParity;  // 可设置停止位和奇偶校验
    uint              dwCurrentTxQueue;     // 当前发送队列
    uint              dwCurrentRxQueue;     // 当前接收队列
    uint              dwProvSpec1;          // 提供者特定1
    uint              dwProvSpec2;          // 提供者特定2
    short             wcProvChar[1];        // 提供者字符
};

// 通信超时结构
struct COMMTIMEOUTS
{
    uint              ReadIntervalTimeout;  // 读取间隔超时
    uint              ReadTotalTimeoutMultiplier; // 读取总超时乘数
    uint              ReadTotalTimeoutConstant; // 读取总超时常数
    uint              WriteTotalTimeoutMultiplier; // 写入总超时乘数
    uint              WriteTotalTimeoutConstant; // 写入总超时常数
};

// 通信状态结构
struct COMSTAT
{
    uint              cbInQue;              // 输入队列大小
    uint              cbOutQue;             // 输出队列大小
};

// 复制文件扩展参数结构
struct COPYFILE2_EXTENDED_PARAMETERS
{
    uint              dwSize;               // 结构大小
    uint              dwCopyFlags;          // 复制标志
    PVOID             pfCancel;              // 取消回调
    PVOID             pProgressRoutine;     // 进度回调
    PVOID             pvCallbackContext;    // 回调上下文
};

// 事件日志满信息结构
struct EVENTLOG_FULL_INFORMATION
{
    uint              dwFull;               // 满状态
};

// 文件对齐信息结构
struct FILE_ALIGNMENT_INFO: public FILE_INFO
{
    uint              AlignmentRequirement; // 对齐要求
};

// 文件分配信息结构
struct FILE_ALLOCATION_INFO: public FILE_INFO
{
    long              AllocationSize;       // 分配大小
};

// 文件属性标签信息结构
struct FILE_ATTRIBUTE_TAG_INFO: public FILE_INFO
{
    uint              FileAttributes;       // 文件属性
    uint              ReparseTag;           // 重解析标签
};

// 文件基本信息结构
struct FILE_BASIC_INFO: public FILE_INFO
{
    long              CreationTime;         // 创建时间
    long              LastAccessTime;       // 最后访问时间
    long              LastWriteTime;        // 最后写入时间
    long              ChangeTime;           // 更改时间
    uint              FileAttributes;       // 文件属性
};

// 文件压缩信息结构
struct FILE_COMPRESSION_INFO: public FILE_INFO
{
    long              CompressedFileSize;   // 压缩文件大小
    ushort            CompressionFormat;   // 压缩格式
    uchar             CompressionUnitShift; // 压缩单元移位
    uchar             ChunkShift;           // 块移位
    uchar             ClusterShift;          // 簇移位
    uchar             Reserved[3];          // 保留字段
};

// 文件处置信息结构
struct FILE_DISPOSITION_INFO: public FILE_INFO
{
    uchar             DeleteFile;           // 删除文件标志
};

// 扩展文件处置信息结构
struct FILE_DISPOSITION_INFO_EX: public FILE_INFO
{
    uint              Flags;                // 标志位
};

// 文件结束位置信息结构
struct FILE_END_OF_FILE_INFO: public FILE_INFO
{
    long              EndOfFile;            // 文件结束位置
};

// 文件完整目录信息结构
struct FILE_FULL_DIR_INFO: public FILE_INFO
{
    uint              NextEntryOffset;      // 下一个条目偏移
    uint              FileIndex;            // 文件索引
    long              CreationTime;         // 创建时间
    long              LastAccessTime;       // 最后访问时间
    long              LastWriteTime;        // 最后写入时间
    long              ChangeTime;           // 更改时间
    long              EndOfFile;            // 文件结束位置
    long              AllocationSize;       // 分配大小
    uint              FileAttributes;       // 文件属性
    uint              FileNameLength;       // 文件名长度
    uint              EaSize;               // 扩展属性大小
    short             FileName[1];          // 文件名
};

// 文件ID目录信息结构
struct FILE_ID_BOTH_DIR_INFO: public FILE_INFO
{
    uint              NextEntryOffset;      // 下一个条目偏移
    uint              FileIndex;            // 文件索引
    long              CreationTime;         // 创建时间
    long              LastAccessTime;       // 最后访问时间
    long              LastWriteTime;        // 最后写入时间
    long              ChangeTime;           // 更改时间
    long              EndOfFile;            // 文件结束位置
    long              AllocationSize;       // 分配大小
    uint              FileAttributes;       // 文件属性
    uint              FileNameLength;       // 文件名长度
    uint              EaSize;               // 扩展属性大小
    char              ShortNameLength;      // 短文件名长度
    short             ShortName[12];        // 短文件名
    long              FileId;               // 文件ID
    short             FileName[1];          // 文件名
};

// 扩展文件ID目录信息结构
struct FILE_ID_EXTD_DIR_INFO: public FILE_INFO
{
    uint              NextEntryOffset;      // 下一个条目偏移
    uint              FileIndex;            // 文件索引
    long              CreationTime;         // 创建时间
    long              LastAccessTime;       // 最后访问时间
    long              LastWriteTime;        // 最后写入时间
    long              ChangeTime;           // 更改时间
    long              EndOfFile;            // 文件结束位置
    long              AllocationSize;       // 分配大小
    uint              FileAttributes;       // 文件属性
    uint              FileNameLength;       // 文件名长度
    uint              EaSize;               // 扩展属性大小
    uint              ReparsePointTag;      // 重解析点标签
    FILE_ID_128       FileId;               // 文件ID
    short             FileName[1];          // 文件名
};

// 文件ID信息结构
struct FILE_ID_INFO: public FILE_INFO
{
    ulong             VolumeSerialNumber;   // 卷序列号
    FILE_ID_128       FileId;               // 文件ID
};

// 文件IO优先级提示信息结构
struct FILE_IO_PRIORITY_HINT_INFO: public FILE_INFO
{
    PRIORITY_HINT     PriorityHint;         // 优先级提示
};

// 文件名信息结构
struct FILE_NAME_INFO
{
    uint              FileNameLength;       // 文件名长度
    short             FileName[2];          // 文件名
};

// 文件标准信息结构
struct FILE_STANDARD_INFO: public FILE_INFO
{
    long              AllocationSize;       // 分配大小
    long              EndOfFile;            // 文件结束位置
    uint              NumberOfLinks;         // 链接数
    uchar             DeletePending;        // 删除挂起标志
    uchar             Directory;            // 目录标志
};

// 文件存储信息结构
struct FILE_STORAGE_INFO: public FILE_INFO
{
    uint              LogicalBytesPerSector; // 逻辑字节/扇区
    uint              PhysicalBytesPerSectorForAtomicity; // 原子性物理字节/扇区
    uint              PhysicalBytesPerSectorForPerformance; // 性能物理字节/扇区
    uint              FileSystemEffectivePhysicalBytesPerSectorForAtomicity; // 文件系统有效原子性物理字节/扇区
    uint              Flags;                // 标志位
    uint              ByteOffsetForSectorAlignment; // 扇区对齐字节偏移
    uint              ByteOffsetForPartitionAlignment; // 分区对齐字节偏移
};

// 文件流信息结构
struct FILE_STREAM_INFO: public FILE_INFO
{
    uint              NextEntryOffset;      // 下一个条目偏移
    uint              StreamNameLength;     // 流名称长度
    long              StreamSize;           // 流大小
    long              StreamAllocationSize; // 流分配大小
    short             StreamName[1];        // 流名称
};

// 硬件配置文件信息结构
struct HW_PROFILE_INFOW
{
    uint              dwDockInfo;           // 停靠信息
    short             szHwProfileGuid[HW_PROFILE_GUIDLEN]; // 硬件配置文件GUID
    short             szHwProfileName[MAX_PROFILE_LEN]; // 硬件配置文件名称
};

// JIT调试信息结构
struct JIT_DEBUG_INFO
{
    uint              dwSize;               // 结构大小
    uint              dwProcessorArchitecture; // 处理器架构
    uint              dwThreadID;           // 线程ID
    uint              dwReserved0;          // 保留字段0
    ulong             lpExceptionAddress;   // 异常地址
    ulong             lpExceptionRecord;    // 异常记录
    ulong             lpContextRecord;      // 上下文记录
};

// 内存状态结构
struct MEMORYSTATUS
{
    uint              dwLength;             // 结构大小
    uint              dwMemoryLoad;          // 内存负载
    ulong             dwTotalPhys;           // 总物理内存
    ulong             dwAvailPhys;          // 可用物理内存
    ulong             dwTotalPageFile;       // 总分页文件
    ulong             dwAvailPageFile;       // 可用分页文件
    ulong             dwTotalVirtual;        // 总虚拟内存
    ulong             dwAvailVirtual;        // 可用虚拟内存
};

// 打开文件结构
struct OFSTRUCT
{
    uchar             cBytes;               // 结构大小
    uchar             fFixedDisk;          // 固定磁盘标志
    ushort            nErrCode;            // 错误代码
    ushort            Reserved1;           // 保留字段1
    ushort            Reserved2;           // 保留字段2
    char              szPathName[OFS_MAXPATHNAME]; // 路径名
};

// 操作结束参数结构
struct OPERATION_END_PARAMETERS
{
    uint              Version;              // 版本号
    uint              OperationId;          // 操作ID
    uint              Flags;                // 标志位
};

// 操作开始参数结构
struct OPERATION_START_PARAMETERS
{
    uint              Version;              // 版本号
    uint              OperationId;          // 操作ID
    uint              Flags;                // 标志位
};

// 系统电源状态结构
struct SYSTEM_POWER_STATUS
{
    uchar             ACLineStatus;         // AC线路状态
    uchar             BatteryFlag;         // 电池标志
    uchar             BatteryLifePercent;   // 电池剩余百分比
    uchar             SystemStatusFlag;     // 系统状态标志
    uint              BatteryLifeTime;      // 电池剩余时间
    uint              BatteryFullLifeTime;  // 电池完全充电时间
};

// UMS调度器启动信息结构
struct UMS_SCHEDULER_STARTUP_INFO
{
    uint              UmsVersion;           // UMS版本
    PVOID             CompletionList;        // 完成列表
    PVOID             SchedulerProc;        // 调度器过程
    PVOID             SchedulerParam;       // 调度器参数
};

// Win32流ID结构
struct WIN32_STREAM_ID
{
    uint              dwStreamId;           // 流ID
    uint              dwStreamAttributes;  // 流属性
    long              Size;                 // 大小
    uint              dwStreamNameSize;     // 流名称大小
};

// UMS系统线程信息结构
struct UMS_SYSTEM_THREAD_INFORMATION
{
    uint              UmsVersion;           // UMS版本
    uint              ThreadUmsFlags;       // 线程UMS标志
};

// 文件ID描述符结构
struct FILE_ID_DESCRIPTOR
{
    uint              dwSize;               // 结构大小
    FILE_ID_TYPE      Type;                 // 文件ID类型
    long              FileId;               // 文件ID
};

// 系统时间结构
struct SYSTEMTIME
{
    ushort            wYear;                // 年
    ushort            wMonth;               // 月
    ushort            wDayOfWeek;           // 星期
    ushort            wDay;                 // 日
    ushort            wHour;                // 时
    ushort            wMinute;              // 分
    ushort            wSecond;              // 秒
    ushort            wMilliseconds;       // 毫秒
};

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#import "kernel32.dll"
/// 激活激活上下文
/// @param act_ctx 激活上下文句柄
/// @param cookie 返回的cookie
/// @return 操作结果
int ActivateActCtx(HANDLE act_ctx, PVOID &cookie);

/// 激活激活上下文
/// @param act_ctx 激活上下文结构
/// @param cookie 返回的cookie
/// @return 操作结果
int ActivateActCtx(ACTCTXW &act_ctx, PVOID &cookie);

/// 添加原子
/// @param str 字符串
/// @return 原子句柄
ushort AddAtomW(const string str);

/// 添加完整性标签到边界描述符
/// @param BoundaryDescriptor 边界描述符
/// @param IntegrityLabel 完整性标签
/// @return 操作结果
int AddIntegrityLabelToBoundaryDescriptor(HANDLE &BoundaryDescriptor, SID &IntegrityLabel);

/// 增加激活上下文引用计数
/// @param act_ctx 激活上下文句柄
void AddRefActCtx(HANDLE act_ctx);

/// 增加激活上下文引用计数
/// @param act_ctx 激活上下文结构
void AddRefActCtx(ACTCTXW &act_ctx);

/// 添加安全内存缓存回调
/// @param call_back 回调函数
/// @return 操作结果
int AddSecureMemoryCacheCallback(PVOID call_back);

/// 应用程序恢复完成
/// @param success 成功标志
void ApplicationRecoveryFinished(int success);

/// 应用程序恢复进行中
/// @param cancelled 返回的取消标志
/// @return 操作结果
int ApplicationRecoveryInProgress(int &cancelled);

/// 备份读取
/// @param file 文件句柄
/// @param buffer 缓冲区
/// @param number_of_bytes_to_read 要读取的字节数
/// @param number_of_bytes_read 已读取字节数
/// @param abort 中止标志
/// @param process_security 处理安全标志
/// @param context 上下文
/// @return 操作结果
int BackupRead(HANDLE file, uchar &buffer[], uint number_of_bytes_to_read, uint &number_of_bytes_read, int abort, int process_security, PVOID &context);

/// 备份查找
/// @param file 文件句柄
/// @param low_bytes_to_seek 低字节偏移
/// @param high_bytes_to_seek 高字节偏移
/// @param low_byte_seeked 低字节偏移结果
/// @param high_byte_seeked 高字节偏移结果
/// @param context 上下文
/// @return 操作结果
int BackupSeek(HANDLE file, uint low_bytes_to_seek, uint high_bytes_to_seek, uint &low_byte_seeked, uint &high_byte_seeked, PVOID &context);

/// 备份写入
/// @param file 文件句柄
/// @param buffer 缓冲区
/// @param number_of_bytes_to_write 要写入的字节数
/// @param number_of_bytes_written 已写入字节数
/// @param abort 中止标志
/// @param process_security 处理安全标志
/// @param context 上下文
/// @return 操作结果
int BackupWrite(HANDLE file, uchar &buffer[], uint number_of_bytes_to_write, uint &number_of_bytes_written, int abort, int process_security, PVOID &context);

/// 开始更新资源
/// @param file_name 文件名
/// @param delete_existing_resources 删除现有资源标志
/// @return 更新句柄
HANDLE BeginUpdateResourceW(const string file_name, int delete_existing_resources);

/// 绑定IO完成回调
/// @param FileHandle 文件句柄
/// @param Function 回调函数
/// @param Flags 标志位
/// @return 操作结果
int BindIoCompletionCallback(HANDLE FileHandle, PVOID Function, uint Flags);

/// 构建通信DCB和超时设置
/// @param def 定义字符串
/// @param lpDCB DCB结构
/// @param comm_timeouts 通信超时结构
/// @return 操作结果
int BuildCommDCBAndTimeoutsW(const string def, DCB &lpDCB, COMMTIMEOUTS &comm_timeouts);

/// 构建通信DCB
/// @param def 定义字符串
/// @param lpDCB DCB结构
/// @return 操作结果
int BuildCommDCBW(const string def, DCB &lpDCB);

/// 取消设备唤醒请求
/// @param device 设备句柄
/// @return 操作结果
int CancelDeviceWakeupRequest(HANDLE device);

/// 取消定时器队列定时器
/// @param TimerQueue 定时器队列
/// @param Timer 定时器
/// @return 操作结果
int CancelTimerQueueTimer(HANDLE TimerQueue, HANDLE Timer);

/// 检查DOS 8.3名称合法性
/// @param name 名称
/// @param oem_name OEM名称
/// @param oem_name_size OEM名称大小
/// @param name_contains_spaces 名称包含空格标志
/// @param name_legal 名称合法标志
/// @return 操作结果
int CheckNameLegalDOS8Dot3W(const string name, char &oem_name[], uint oem_name_size, int &name_contains_spaces, int &name_legal);

/// 清除通信中断
/// @param file 文件句柄
/// @return 操作结果
int ClearCommBreak(HANDLE file);

/// 清除通信错误
/// @param file 文件句柄
/// @param errors 错误码
/// @param stat 通信状态
/// @return 操作结果
int ClearCommError(HANDLE file, uint &errors, COMSTAT &stat);

/// 通信配置对话框
/// @param name 名称
/// @param wnd 窗口句柄
/// @param lpCC 通信配置
/// @return 操作结果
int CommConfigDialogW(const string name, HANDLE wnd, COMMCONFIG &lpCC);

/// 转换纤程为线程
/// @return 操作结果
int ConvertFiberToThread(void);

/// 转换线程为纤程
/// @param parameter 参数
/// @return 纤程地址
PVOID ConvertThreadToFiber(PVOID parameter);

/// 转换线程为纤程(扩展)
/// @param parameter 参数
/// @param flags 标志位
/// @return 纤程地址
PVOID ConvertThreadToFiberEx(PVOID parameter, uint flags);

/// 复制上下文
/// @param Destination 目标上下文
/// @param ContextFlags 上下文标志
/// @param Source 源上下文
/// @return 操作结果
int CopyContext(CONTEXT &Destination, uint ContextFlags, CONTEXT &Source);

/// 复制文件2
/// @param existing_file_name 源文件名
/// @param new_file_name 目标文件名
/// @param extended_parameters 扩展参数
/// @return 操作结果
int CopyFile2(const string existing_file_name, const string new_file_name, COPYFILE2_EXTENDED_PARAMETERS &extended_parameters);

/// 复制文件(扩展)
/// @param existing_file_name 源文件名
/// @param new_file_name 目标文件名
/// @param progress_routine 进度回调
/// @param data 回调数据
/// @param cancel 取消标志
/// @param copy_flags 复制标志
/// @return 操作结果
int CopyFileExW(const string existing_file_name, const string new_file_name, PVOID progress_routine, PVOID data, int &cancel, uint copy_flags);

/// 复制文件(事务)
/// @param existing_file_name 源文件名
/// @param new_file_name 目标文件名
/// @param progress_routine 进度回调
/// @param data 回调数据
/// @param cancel 取消标志
/// @param copy_flags 复制标志
/// @param transaction 事务句柄
/// @return 操作结果
int CopyFileTransactedW(const string existing_file_name, const string new_file_name, PVOID progress_routine, PVOID data, int &cancel, uint copy_flags, HANDLE transaction);

/// 复制文件
/// @param existing_file_name 源文件名
/// @param new_file_name 目标文件名
/// @param fail_if_exists 存在时失败标志
/// @return 操作结果
int CopyFileW(const string existing_file_name, const string new_file_name, int fail_if_exists);

/// 创建激活上下文
/// @param act_ctx 激活上下文结构
/// @return 激活上下文句柄
HANDLE CreateActCtxW(const ACTCTXW &act_ctx);

/// 创建目录(扩展)
/// @param template_directory 模板目录
/// @param new_directory 新目录
/// @param security_attributes 安全属性
/// @return 操作结果
int CreateDirectoryExW(const string template_directory, const string new_directory, PVOID security_attributes);

/// 创建目录(事务)
/// @param template_directory 模板目录
/// @param new_directory 新目录
/// @param security_attributes 安全属性
/// @param transaction 事务句柄
/// @return 操作结果
int CreateDirectoryTransactedW(const string template_directory, const string new_directory, PVOID security_attributes, HANDLE transaction);

/// 创建纤程
/// @param stack_size 堆栈大小
/// @param start_address 起始地址
/// @param parameter 参数
/// @return 纤程地址
PVOID CreateFiber(ulong stack_size, PVOID start_address, PVOID parameter);

/// 创建纤程(扩展)
/// @param stack_commit_size 堆栈提交大小
/// @param stack_reserve_size 堆栈保留大小
/// @param flags 标志位
/// @param start_address 起始地址
/// @param parameter 参数
/// @return 纤程地址
PVOID CreateFiberEx(ulong stack_commit_size, ulong stack_reserve_size, uint flags, PVOID start_address, PVOID parameter);

/// 创建文件(事务)
/// @param file_name 文件名
/// @param desired_access 访问权限
/// @param share_mode 共享模式
/// @param security_attributes 安全属性
/// @param creation_disposition 创建方式
/// @param flags_and_attributes 标志和属性
/// @param template_file 模板文件
/// @param transaction 事务句柄
/// @param mini_version 小版本
/// @param extended_parameter 扩展参数
/// @return 文件句柄
HANDLE CreateFileTransactedW(const string file_name, uint desired_access, uint share_mode, PVOID security_attributes, uint creation_disposition, uint flags_and_attributes, HANDLE template_file, HANDLE transaction, ushort &mini_version, PVOID extended_parameter);

/// 创建硬链接(事务)
/// @param file_name 文件名
/// @param existing_file_name 现有文件名
/// @param security_attributes 安全属性
/// @param transaction 事务句柄
/// @return 操作结果
int CreateHardLinkTransactedW(const string file_name, const string existing_file_name, PVOID security_attributes, HANDLE transaction);

/// 创建硬链接
/// @param file_name 文件名
/// @param existing_file_name 现有文件名
/// @param security_attributes 安全属性
/// @return 操作结果
int CreateHardLinkW(const string file_name, const string existing_file_name, PVOID security_attributes);

/// 创建作业集
/// @param NumJob 作业数量
/// @param UserJobSet 用户作业集
/// @param Flags 标志位
/// @return 操作结果
int CreateJobSet(uint NumJob, JOB_SET_ARRAY &UserJobSet, uint Flags);

/// 创建邮件槽
/// @param name 名称
/// @param max_message_size 最大消息大小
/// @param read_timeout 读取超时
/// @param security_attributes 安全属性
/// @return 邮件槽句柄
HANDLE CreateMailslotW(const string name, uint max_message_size, uint read_timeout, PVOID security_attributes);

/// 创建符号链接(事务)
/// @param symlink_file_name 符号链接文件名
/// @param target_file_name 目标文件名
/// @param flags 标志位
/// @param transaction 事务句柄
/// @return 操作结果
uchar CreateSymbolicLinkTransactedW(const string symlink_file_name, const string target_file_name, uint flags, HANDLE transaction);

/// 创建符号链接
/// @param symlink_file_name 符号链接文件名
/// @param target_file_name 目标文件名
/// @param flags 标志位
/// @return 操作结果
uchar CreateSymbolicLinkW(const string symlink_file_name, const string target_file_name, uint flags);

/// 创建磁带分区
/// @param device 设备句柄
/// @param partition_method 分区方法
/// @param count 分区数量
/// @param size 分区大小
/// @return 操作结果
uint CreateTapePartition(HANDLE device, uint partition_method, uint count, uint size);

/// 创建UMS完成列表
/// @param UmsCompletionList 返回的UMS完成列表
/// @return 操作结果
int CreateUmsCompletionList(PVOID &UmsCompletionList);

/// 创建UMS线程上下文
/// @param ums_thread 返回的UMS线程
/// @return 操作结果
int CreateUmsThreadContext(PVOID &ums_thread);

/// 停用激活上下文
/// @param flags 标志位
/// @param cookie cookie值
/// @return 操作结果
int DeactivateActCtx(uint flags, ulong cookie);

/// 调试中断进程
/// @param Process 进程句柄
/// @return 操作结果
int DebugBreakProcess(HANDLE Process);

/// 设置进程退出时终止
/// @param KillOnExit 终止标志
/// @return 操作结果
int DebugSetProcessKillOnExit(int KillOnExit);

/// 删除原子
/// @param atom 原子句柄
/// @return 操作结果
ushort DeleteAtom(ushort atom);

/// 删除纤程
/// @param fiber 纤程地址
void DeleteFiber(PVOID fiber);

/// 删除文件(事务)
/// @param file_name 文件名
/// @param transaction 事务句柄
/// @return 操作结果
int DeleteFileTransactedW(const string file_name, HANDLE transaction);

/// 删除定时器队列
/// @param TimerQueue 定时器队列
/// @return 操作结果
int DeleteTimerQueue(HANDLE TimerQueue);

/// 删除UMS完成列表
/// @param UmsCompletionList UMS完成列表
/// @return 操作结果
int DeleteUmsCompletionList(PVOID UmsCompletionList);

/// 删除UMS线程上下文
/// @param UmsThread UMS线程
/// @return 操作结果
int DeleteUmsThreadContext(PVOID UmsThread);

/// 出队UMS完成列表项
/// @param UmsCompletionList UMS完成列表
/// @param WaitTimeOut 等待超时
/// @param UmsThreadList 返回的UMS线程列表
/// @return 操作结果
int DequeueUmsCompletionListItems(PVOID UmsCompletionList, uint WaitTimeOut, PVOID &UmsThreadList);

/// 禁用线程性能分析
/// @param PerformanceDataHandle 性能数据句柄
/// @return 操作结果
uint DisableThreadProfiling(HANDLE PerformanceDataHandle);

/// DNS主机名转计算机名
/// @param hostname 主机名
/// @param computer_name 计算机名
/// @param size 大小
/// @return 操作结果
int DnsHostnameToComputerNameW(const string hostname, ushort &computer_name[], uint &size);

/// DOS日期时间转文件时间
/// @param fat_date DOS日期
/// @param fat_time DOS时间
/// @param file_time 文件时间
/// @return 操作结果
int DosDateTimeToFileTime(ushort fat_date, ushort fat_time, FILETIME &file_time);

/// 启用线程性能分析
/// @param ThreadHandle 线程句柄
/// @param Flags 标志位
/// @param HardwareCounters 硬件计数器
/// @param PerformanceDataHandle 返回的性能数据句柄
/// @return 操作结果
uint EnableThreadProfiling(HANDLE ThreadHandle, uint Flags, ulong HardwareCounters, HANDLE &PerformanceDataHandle);

/// 结束更新资源
/// @param update 更新句柄
/// @param discard 丢弃标志
/// @return 操作结果
int EndUpdateResourceW(HANDLE update, int discard);

/// 进入UMS调度模式
/// @param SchedulerStartupInfo 调度器启动信息
/// @return 操作结果
int EnterUmsSchedulingMode(UMS_SCHEDULER_STARTUP_INFO &SchedulerStartupInfo);

/// 枚举资源语言
/// @param module 模块句柄
/// @param type 资源类型
/// @param name 资源名称
/// @param enum_func 枚举函数
/// @param param 参数
/// @return 操作结果
int EnumResourceLanguagesW(HANDLE module, const string type, const string name, PVOID enum_func, long param);

/// 枚举资源类型
/// @param module 模块句柄
/// @param enum_func 枚举函数
/// @param param 参数
/// @return 操作结果
int EnumResourceTypesW(HANDLE module, PVOID enum_func, long param);

/// 擦除磁带
/// @param device 设备句柄
/// @param erase_type 擦除类型
/// @param immediate 立即标志
/// @return 操作结果
uint EraseTape(HANDLE device, uint erase_type, int immediate);

/// 执行通信功能
/// @param file 文件句柄
/// @param func 功能代码
/// @return 操作结果
int EscapeCommFunction(HANDLE file, uint func);

/// 执行UMS线程
/// @param UmsThread UMS线程
/// @return 操作结果
int ExecuteUmsThread(PVOID UmsThread);

/// 致命退出
/// @param ExitCode 退出代码
void FatalExit(int ExitCode);

/// 文件时间转DOS日期时间
/// @param file_time 文件时间
/// @param fat_date 返回的DOS日期
/// @param fat_time 返回的DOS时间
/// @return 操作结果
int FileTimeToDosDateTime(FILETIME &file_time, ushort &fat_date, ushort &fat_time);

/// 查找激活上下文部分GUID
/// @param flags 标志位
/// @param extension_guid 扩展GUID
/// @param section_id 部分ID
/// @param guid_to_find 要查找的GUID
/// @param ReturnedData 返回的数据
/// @return 操作结果
int FindActCtxSectionGuid(uint flags, const GUID &extension_guid[], uint section_id, const GUID &guid_to_find[], ACTCTX_SECTION_KEYED_DATA &ReturnedData);

/// 查找激活上下文部分字符串
/// @param flags 标志位
/// @param extension_guid 扩展GUID
/// @param section_id 部分ID
/// @param string_to_find 要查找的字符串
/// @param ReturnedData 返回的数据
/// @return 操作结果
int FindActCtxSectionStringW(uint flags, const GUID &extension_guid[], uint section_id, const string string_to_find, ACTCTX_SECTION_KEYED_DATA &ReturnedData);

/// 查找原子
/// @param str 字符串
/// @return 原子句柄
ushort FindAtomW(const string str);

/// 查找第一个文件名(事务)
/// @param file_name 文件名
/// @param flags 标志位
/// @param StringLength 字符串长度
/// @param LinkName 链接名
/// @param transaction 事务句柄
/// @return 查找句柄
HANDLE FindFirstFileNameTransactedW(const string file_name, uint flags, uint &StringLength, string LinkName, HANDLE transaction);

/// 查找第一个文件(事务)
/// @param file_name 文件名
/// @param info_level_id 信息级别
/// @param find_file_data 文件数据
/// @param search_op 搜索操作
/// @param search_filter 搜索过滤器
/// @param additional_flags 附加标志
/// @param transaction 事务句柄
/// @return 查找句柄
HANDLE FindFirstFileTransactedW(const string file_name, FINDEX_INFO_LEVELS info_level_id, FIND_DATAW &find_file_data, FINDEX_SEARCH_OPS search_op, PVOID search_filter, uint additional_flags, HANDLE transaction);

/// 查找第一个流(事务)
/// @param file_name 文件名
/// @param InfoLevel 信息级别
/// @param find_stream_data 流数据
/// @param flags 标志位
/// @param transaction 事务句柄
/// @return 查找句柄
HANDLE FindFirstStreamTransactedW(const string file_name, STREAM_INFO_LEVELS InfoLevel, FIND_STREAM_DATA &find_stream_data, uint flags, HANDLE transaction);

/// 查找第一个卷挂载点
/// @param root_path_name 根路径名
/// @param volume_mount_point 卷挂载点
/// @param buffer_length 缓冲区长度
/// @return 查找句柄
HANDLE FindFirstVolumeMountPointW(const string root_path_name, ushort &volume_mount_point[], uint buffer_length);

/// 查找下一个卷挂载点
/// @param find_volume_mount_point 查找句柄
/// @param volume_mount_point 卷挂载点
/// @param buffer_length 缓冲区长度
/// @return 操作结果
int FindNextVolumeMountPointW(HANDLE find_volume_mount_point, string volume_mount_point, uint buffer_length);

/// 关闭卷挂载点查找句柄
/// @param find_volume_mount_point 查找句柄
/// @return 操作结果
int FindVolumeMountPointClose(HANDLE find_volume_mount_point);

/// 格式化消息
/// @param flags 标志位
/// @param source 源
/// @param message_id 消息ID
/// @param language_id 语言ID
/// @param buffer 缓冲区
/// @param size 大小
/// @param Arguments 参数
/// @return 格式化长度
uint FormatMessageW(uint flags, const uchar &source[], uint message_id, uint language_id, ushort &buffer[], uint size, PVOID &Arguments[]);

/// 获取活动处理器数量
/// @param GroupNumber 组号
/// @return 处理器数量
uint GetActiveProcessorCount(ushort GroupNumber);

/// 获取活动处理器组数量
/// @return 组数量
ushort GetActiveProcessorGroupCount(void);

/// 获取应用程序恢复回调
/// @param process 进程句柄
/// @param recovery_callback 恢复回调
/// @param parameter 参数
/// @param ping_interval ping间隔
/// @param flags 标志位
/// @return 操作结果
int GetApplicationRecoveryCallback(HANDLE process, PVOID &recovery_callback, PVOID &parameter, uint &ping_interval, uint &flags);

/// 获取应用程序重启设置
/// @param process 进程句柄
/// @param commandline 命令行
/// @param size 大小
/// @param flags 标志位
/// @return 操作结果
int GetApplicationRestartSettings(HANDLE process, ushort &commandline[], uint &size, uint &flags);

/// 获取原子名称
/// @param atom 原子句柄
/// @param buffer 缓冲区
/// @param size 大小
/// @return 名称长度
uint GetAtomNameW(ushort atom, ushort &buffer[], int size);

/// 获取二进制类型
/// @param application_name 应用程序名
/// @param binary_type 二进制类型
/// @return 操作结果
int GetBinaryTypeW(const string application_name, uint &binary_type);

/// 获取通信配置
/// @param comm_dev 通信设备
/// @param lpCC 通信配置
/// @param size 大小
/// @return 操作结果
int GetCommConfig(HANDLE comm_dev, COMMCONFIG &lpCC, uint &size);

/// 获取通信掩码
/// @param file 文件句柄
/// @param evt_mask 事件掩码
/// @return 操作结果
int GetCommMask(HANDLE file, uint &evt_mask);

/// 获取通信调制解调器状态
/// @param file 文件句柄
/// @param modem_stat 调制解调器状态
/// @return 操作结果
int GetCommModemStatus(HANDLE file, uint &modem_stat);

/// 获取通信属性
/// @param file 文件句柄
/// @param comm_prop 通信属性
/// @return 操作结果
int GetCommProperties(HANDLE file, COMMPROP &comm_prop);

/// 获取通信状态
/// @param file 文件句柄
/// @param lpDCB DCB结构
/// @return 操作结果
int GetCommState(HANDLE file, DCB &lpDCB);

/// 获取通信超时
/// @param file 文件句柄
/// @param comm_timeouts 通信超时
/// @return 操作结果
int GetCommTimeouts(HANDLE file, COMMTIMEOUTS &comm_timeouts);

/// 获取压缩文件大小(事务)
/// @param file_name 文件名
/// @param file_size_high 文件大小高32位
/// @param transaction 事务句柄
/// @return 文件大小低32位
uint GetCompressedFileSizeTransactedW(const string file_name, uint &file_size_high, HANDLE transaction);

/// 获取计算机名
/// @param buffer 缓冲区
/// @param size 大小
/// @return 操作结果
int GetComputerNameW(ushort &buffer[], uint &size);

/// 获取当前激活上下文
/// @param act_ctx 激活上下文句柄
/// @return 操作结果
int GetCurrentActCtx(HANDLE &act_ctx);

/// 获取当前激活上下文
/// @param act_ctx 激活上下文结构
/// @return 操作结果
int GetCurrentActCtx(ACTCTXW &act_ctx);

/// 获取当前UMS线程
/// @return UMS线程
PVOID GetCurrentUmsThread(void);

/// 获取默认通信配置
/// @param name 名称
/// @param lpCC 通信配置
/// @param size 大小
/// @return 操作结果
int GetDefaultCommConfigW(const string name, COMMCONFIG &lpCC, uint &size);

/// 获取设备电源状态
/// @param device 设备句柄
/// @param on 电源状态
/// @return 操作结果
int GetDevicePowerState(HANDLE device, int &on);

/// 获取DLL目录
/// @param buffer_length 缓冲区长度
/// @param buffer 缓冲区
/// @return 目录长度
uint GetDllDirectoryW(uint buffer_length, ushort &buffer[]);

/// 获取启用的XState特性
/// @return 特性掩码
ulong GetEnabledXStateFeatures(void);

/// 获取文件属性(事务)
/// @param file_name 文件名
/// @param info_level_id 信息级别
/// @param file_information 文件信息
/// @param transaction 事务句柄
/// @return 操作结果
int GetFileAttributesTransactedW(const string file_name, GET_FILEEX_INFO_LEVELS info_level_id, PVOID file_information, HANDLE transaction);

/// 获取文件带宽预留
/// @param file 文件句柄
/// @param period_milliseconds 周期毫秒数
/// @param bytes_per_period 每周期字节数
/// @param discardable 可丢弃标志
/// @param transfer_size 传输大小
/// @param num_outstanding_requests 未完成请求数
/// @return 操作结果
int GetFileBandwidthReservation(HANDLE file, uint &period_milliseconds, uint &bytes_per_period, int &discardable, uint &transfer_size, uint &num_outstanding_requests);

/// 通过句柄获取文件信息
/// @param file 文件句柄
/// @param FileInformationClass 文件信息类
/// @param file_information 文件信息
/// @param buffer_size 缓冲区大小
/// @return 操作结果
int GetFileInformationByHandleEx(HANDLE file, FILE_INFO_BY_HANDLE_CLASS FileInformationClass, PVOID file_information, uint buffer_size);

/// 通过句柄获取文件信息(字节数组版本)
/// @param file 文件句柄
/// @param FileInformationClass 文件信息类
/// @param file_information 文件信息
/// @param buffer_size 缓冲区大小
/// @return 操作结果
int GetFileInformationByHandleEx(HANDLE file, FILE_INFO_BY_HANDLE_CLASS FileInformationClass, uchar &file_information[], uint buffer_size);

/// 获取固件环境变量(扩展)
/// @param name 名称
/// @param guid GUID
/// @param buffer 缓冲区
/// @param size 大小
/// @param attribubutes 属性
/// @return 数据长度
uint GetFirmwareEnvironmentVariableExW(const string name, const string guid, PVOID buffer, uint size, uint &attribubutes);

/// 获取固件环境变量
/// @param name 名称
/// @param guid GUID
/// @param buffer 缓冲区
/// @param size 大小
/// @return 数据长度
uint GetFirmwareEnvironmentVariableW(const string name, const string guid, PVOID buffer, uint size);

/// 获取固件类型
/// @param FirmwareType 固件类型
/// @return 操作结果
int GetFirmwareType(FIRMWARE_TYPE &FirmwareType);

/// 获取完整路径名(事务)
/// @param file_name 文件名
/// @param buffer_length 缓冲区长度
/// @param buffer 缓冲区
/// @param file_part 文件部分
/// @param transaction 事务句柄
/// @return 路径长度
uint GetFullPathNameTransactedW(const string file_name, uint buffer_length, string buffer, string &file_part, HANDLE transaction);

/// 获取长路径名(事务)
/// @param short_path 短路径
/// @param long_path 长路径
/// @param buffer 缓冲区大小
/// @param transaction 事务句柄
/// @return 路径长度
uint GetLongPathNameTransactedW(const string short_path, string long_path, uint buffer, HANDLE transaction);

/// 获取邮件槽信息
/// @param mailslot 邮件槽句柄
/// @param max_message_size 最大消息大小
/// @param next_size 下一条消息大小
/// @param message_count 消息计数
/// @param read_timeout 读取超时
/// @return 操作结果
int GetMailslotInfo(HANDLE mailslot, uint &max_message_size, uint &next_size, uint &message_count, uint &read_timeout);

/// 获取最大处理器数量
/// @param GroupNumber 组号
/// @return 处理器数量
uint GetMaximumProcessorCount(ushort GroupNumber);

/// 获取最大处理器组数量
/// @return 组数量
ushort GetMaximumProcessorGroupCount(void);

/// 获取命名管道客户端进程ID
/// @param Pipe 管道句柄
/// @param ClientProcessId 客户端进程ID
/// @return 操作结果
int GetNamedPipeClientProcessId(HANDLE Pipe, uint &ClientProcessId);

/// 获取命名管道客户端会话ID
/// @param Pipe 管道句柄
/// @param ClientSessionId 客户端会话ID
/// @return 操作结果
int GetNamedPipeClientSessionId(HANDLE Pipe, uint &ClientSessionId);

/// 获取命名管道服务器进程ID
/// @param Pipe 管道句柄
/// @param ServerProcessId 服务器进程ID
/// @return 操作结果
int GetNamedPipeServerProcessId(HANDLE Pipe, uint &ServerProcessId);

/// 获取命名管道服务器会话ID
/// @param Pipe 管道句柄
/// @param ServerSessionId 服务器会话ID
/// @return 操作结果
int GetNamedPipeServerSessionId(HANDLE Pipe, uint &ServerSessionId);

/// 获取下一个UMS列表项
/// @param UmsContext UMS上下文
/// @return 下一个UMS列表项
PVOID GetNextUmsListItem(PVOID UmsContext);

/// 获取NUMA可用内存节点
/// @param Node 节点
/// @param AvailableBytes 可用字节数
/// @return 操作结果
int GetNumaAvailableMemoryNode(uchar Node, ulong &AvailableBytes);

/// 获取NUMA可用内存节点(扩展)
/// @param Node 节点
/// @param AvailableBytes 可用字节数
/// @return 操作结果
int GetNumaAvailableMemoryNodeEx(ushort Node, ulong &AvailableBytes);

/// 从句柄获取NUMA节点号
/// @param file 文件句柄
/// @param NodeNumber 节点号
/// @return 操作结果
int GetNumaNodeNumberFromHandle(HANDLE file, ushort &NodeNumber);

/// 获取NUMA节点处理器掩码
/// @param Node 节点
/// @param ProcessorMask 处理器掩码
/// @return 操作结果
int GetNumaNodeProcessorMask(uchar Node, ulong &ProcessorMask);

/// 获取NUMA处理器节点
/// @param Processor 处理器
/// @param NodeNumber 节点号
/// @return 操作结果
int GetNumaProcessorNode(uchar Processor, uchar &NodeNumber);

/// 获取NUMA处理器节点(扩展)
/// @param Processor 处理器
/// @param NodeNumber 节点号
/// @return 操作结果
int GetNumaProcessorNodeEx(PROCESSOR_NUMBER &Processor, ushort &NodeNumber);

/// 获取NUMA邻近节点
/// @param ProximityId 邻近ID
/// @param NodeNumber 节点号
/// @return 操作结果
int GetNumaProximityNode(uint ProximityId, uchar &NodeNumber);

/// 获取私有配置文件整数值
/// @param app_name 应用程序名
/// @param key_name 键名
/// @param default_value 默认值
/// @param file_name 文件名
/// @return 整数值
uint GetPrivateProfileIntW(const string app_name, const string key_name, int default_value, const string file_name);

/// 获取私有配置文件节名称
/// @param return_buffer 返回缓冲区
/// @param size 大小
/// @param file_name 文件名
/// @return 名称长度
uint GetPrivateProfileSectionNamesW(string return_buffer, uint size, const string file_name);

/// 获取私有配置文件节
/// @param app_name 应用程序名
/// @param returned_string 返回字符串
/// @param size 大小
/// @param file_name 文件名
/// @return 节长度
uint GetPrivateProfileSectionW(const string app_name, string returned_string, uint size, const string file_name);

/// 获取私有配置文件字符串
/// @param app_name 应用程序名
/// @param key_name 键名
/// @param default_value 默认值
/// @param returned_string 返回字符串
/// @param size 大小
/// @param file_name 文件名
/// @return 字符串长度
uint GetPrivateProfileStringW(const string app_name, const string key_name, const string default_value, string returned_string, uint size, const string file_name);

/// 获取私有配置文件结构
/// @param section 节
/// @param key 键
/// @param struct_obj 结构对象
/// @param size_struct 结构大小
/// @param file 文件
/// @return 操作结果
int GetPrivateProfileStructW(const string section, const string key, PVOID struct_obj, uint size_struct, const string file);

/// 获取进程关联掩码
/// @param process 进程句柄
/// @param process_affinity_mask 进程关联掩码
/// @param system_affinity_mask 系统关联掩码
/// @return 操作结果
int GetProcessAffinityMask(HANDLE process, ulong &process_affinity_mask, ulong &system_affinity_mask);

/// 获取进程DEP策略
/// @param process 进程句柄
/// @param flags 标志位
/// @param permanent 永久标志
/// @return 操作结果
int GetProcessDEPPolicy(HANDLE process, uint &flags, int &permanent);

/// 获取进程IO计数器
/// @param process 进程句柄
/// @param io_counters IO计数器
/// @return 操作结果
int GetProcessIoCounters(HANDLE process, IO_COUNTERS &io_counters);

/// 获取进程工作集大小
/// @param process 进程句柄
/// @param minimum_working_set_size 最小工作集大小
/// @param maximum_working_set_size 最大工作集大小
/// @return 操作结果
int GetProcessWorkingSetSize(HANDLE process, ulong &minimum_working_set_size, ulong &maximum_working_set_size);

/// 获取配置文件整数值
/// @param app_name 应用程序名
/// @param key_name 键名
/// @param default_value 默认值
/// @return 整数值
uint GetProfileIntW(const string app_name, const string key_name, int default_value);

/// 获取配置文件节
/// @param app_name 应用程序名
/// @param returned_string 返回字符串
/// @param size 大小
/// @return 节长度
uint GetProfileSectionW(const string app_name, string returned_string, uint size);

/// 获取配置文件字符串
/// @param app_name 应用程序名
/// @param key_name 键名
/// @param default_value 默认值
/// @param returned_string 返回字符串
/// @param size 大小
/// @return 字符串长度
uint GetProfileStringW(const string app_name, const string key_name, const string default_value, string returned_string, uint size);

/// 获取系统DEP策略
/// @return DEP策略类型
DEP_SYSTEM_POLICY_TYPE GetSystemDEPPolicy(void);

/// 获取系统电源状态
/// @param system_power_status 系统电源状态
/// @return 操作结果
int GetSystemPowerStatus(SYSTEM_POWER_STATUS &system_power_status);

/// 获取系统注册表配额
/// @param quota_allowed 允许的配额
/// @param quota_used 已使用的配额
/// @return 操作结果
int GetSystemRegistryQuota(uint &quota_allowed, uint &quota_used);

/// 获取磁带参数
/// @param device 设备句柄
/// @param operation 操作
/// @param size 大小
/// @param tape_information 磁带信息
/// @return 操作结果
uint GetTapeParameters(HANDLE device, uint operation, uint &size, PVOID tape_information);

/// 获取磁带位置
/// @param device 设备句柄
/// @param position_type 位置类型
/// @param partition 分区
/// @param offset_low 偏移低32位
/// @param offset_high 偏移高32位
/// @return 操作结果
uint GetTapePosition(HANDLE device, uint position_type, uint &partition, uint &offset_low, uint &offset_high);

/// 获取磁带状态
/// @param device 设备句柄
/// @return 磁带状态
uint GetTapeStatus(HANDLE device);

/// 获取线程选择器条目
/// @param thread 线程句柄
/// @param selector 选择器
/// @param selector_entry 选择器条目
/// @return 操作结果
int GetThreadSelectorEntry(HANDLE thread, uint selector, LDT_ENTRY &selector_entry);

/// 获取UMS完成列表事件
/// @param UmsCompletionList UMS完成列表
/// @param UmsCompletionEvent UMS完成事件
/// @return 操作结果
int GetUmsCompletionListEvent(PVOID UmsCompletionList, HANDLE &UmsCompletionEvent);

/// 获取UMS系统线程信息
/// @param ThreadHandle 线程句柄
/// @param SystemThreadInfo 系统线程信息
/// @return 操作结果
int GetUmsSystemThreadInformation(HANDLE ThreadHandle, UMS_SYSTEM_THREAD_INFORMATION &SystemThreadInfo);

/// 获取XState特性掩码
/// @param Context 上下文
/// @param FeatureMask 特性掩码
/// @return 操作结果
int GetXStateFeaturesMask(CONTEXT &Context, ulong &FeatureMask);

/// 全局添加原子(扩展)
/// @param str 字符串
/// @param Flags 标志位
/// @return 原子句柄
ushort GlobalAddAtomExW(const string str, uint Flags);

/// 全局添加原子
/// @param str 字符串
/// @return 原子句柄
ushort GlobalAddAtomW(const string str);

/// 全局内存分配
/// @param flags 标志位
/// @param bytes 字节数
/// @return 内存句柄
HANDLE GlobalAlloc(uint flags, ulong bytes);

/// 全局内存压缩
/// @param min_free 最小空闲
/// @return 压缩后大小
ulong GlobalCompact(uint min_free);

/// 全局删除原子
/// @param atom 原子句柄
/// @return 操作结果
ushort GlobalDeleteAtom(ushort atom);

/// 全局查找原子
/// @param str 字符串
/// @return 原子句柄
ushort GlobalFindAtomW(const string str);

/// 全局固定内存
/// @param mem 内存句柄
void GlobalFix(HANDLE mem);

/// 获取全局内存标志
/// @param mem 内存句柄
/// @return 标志位
uint GlobalFlags(HANDLE mem);

/// 全局释放内存
/// @param mem 内存句柄
/// @return 内存句柄
HANDLE GlobalFree(HANDLE mem);

/// 获取全局原子名称
/// @param atom 原子句柄
/// @param buffer 缓冲区
/// @param size 大小
/// @return 名称长度
uint GlobalGetAtomNameW(ushort atom, ushort &buffer[], int size);

/// 获取全局内存句柄
/// @param mem 内存指针
/// @return 内存句柄
HANDLE GlobalHandle(const PVOID mem);

/// 全局锁定内存
/// @param mem 内存句柄
/// @return 内存指针
PVOID GlobalLock(HANDLE mem);

/// 全局内存状态
/// @param buffer 内存状态
void GlobalMemoryStatus(MEMORYSTATUS &buffer);

/// 全局重新分配内存
/// @param mem 内存句柄
/// @param bytes 字节数
/// @param flags 标志位
/// @return 内存句柄
HANDLE GlobalReAlloc(HANDLE mem, ulong bytes, uint flags);

/// 获取全局内存大小
/// @param mem 内存句柄
/// @return 内存大小
ulong GlobalSize(HANDLE mem);

/// 全局取消固定内存
/// @param mem 内存句柄
void GlobalUnfix(HANDLE mem);

/// 全局解锁内存
/// @param mem 内存句柄
/// @return 操作结果
int GlobalUnlock(HANDLE mem);

/// 全局取消连线内存
/// @param mem 内存句柄
/// @return 操作结果
int GlobalUnWire(HANDLE mem);

/// 全局连线内存
/// @param mem 内存句柄
/// @return 内存指针
PVOID GlobalWire(HANDLE mem);

/// 初始化原子表
/// @param size 大小
/// @return 操作结果
int InitAtomTable(uint size);

/// 初始化上下文
/// @param Buffer 缓冲区
/// @param ContextFlags 上下文标志
/// @param Context 上下文
/// @param ContextLength 上下文长度
/// @return 操作结果
int InitializeContext(uchar &Buffer[], uint ContextFlags, CONTEXT &Context, uint &ContextLength);

/// 初始化上下文
/// @param Buffer 缓冲区
/// @param ContextFlags 上下文标志
/// @param Context 上下文
/// @param ContextLength 上下文长度
/// @return 操作结果
int InitializeContext(PVOID Buffer, uint ContextFlags, CONTEXT &Context, uint &ContextLength);

/// 检查代码指针是否有效
/// @param lpfn 函数指针
/// @return 是否有效
int IsBadCodePtr(PVOID lpfn);

/// 检查大内存读取指针是否有效
/// @param lp 指针
/// @param ucb 大小
/// @return 是否有效
int IsBadHugeReadPtr(PVOID lp, ulong ucb);

/// 检查大内存写入指针是否有效
/// @param lp 指针
/// @param ucb 大小
/// @return 是否有效
int IsBadHugeWritePtr(PVOID lp, ulong ucb);

/// 检查读取指针是否有效
/// @param lp 指针
/// @param ucb 大小
/// @return 是否有效
int IsBadReadPtr(PVOID lp, ulong ucb);

/// 检查字符串指针是否有效
/// @param lpsz 字符串指针
/// @param max 最大长度
/// @return 是否有效
int IsBadStringPtrW(const string lpsz, ulong max);

/// 检查写入指针是否有效
/// @param lp 指针
/// @param ucb 大小
/// @return 是否有效
int IsBadWritePtr(PVOID lp, ulong ucb);

/// 检查是否本地VHD启动
/// @param NativeVhdBoot 本地VHD启动标志
/// @return 操作结果
int IsNativeVhdBoot(int &NativeVhdBoot);

/// 检查系统是否自动恢复
/// @return 是否自动恢复
int IsSystemResumeAutomatic(void);

/// 加载打包库
/// @param lib_file_name 库文件名
/// @param Reserved 保留字段
/// @return 模块句柄
HANDLE LoadPackagedLibrary(const string lib_file_name, uint Reserved);

/// 本地内存分配
/// @param flags 标志位
/// @param bytes 字节数
/// @return 内存句柄
HANDLE LocalAlloc(uint flags, ulong bytes);

/// 本地内存压缩
/// @param min_free 最小空闲
/// @return 压缩后大小
ulong LocalCompact(uint min_free);

/// 获取本地内存标志
/// @param mem 内存句柄
/// @return 标志位
uint LocalFlags(HANDLE mem);

/// 本地释放内存
/// @param mem 内存句柄
/// @return 内存句柄
HANDLE LocalFree(HANDLE mem);

/// 获取本地内存句柄
/// @param mem 内存指针
/// @return 内存句柄
HANDLE LocalHandle(const PVOID mem);

/// 本地锁定内存
/// @param mem 内存句柄
/// @return 内存指针
PVOID LocalLock(HANDLE mem);

/// 本地重新分配内存
/// @param mem 内存句柄
/// @param bytes 字节数
/// @param flags 标志位
/// @return 内存句柄
HANDLE LocalReAlloc(HANDLE mem, ulong bytes, uint flags);

/// 本地内存收缩
/// @param mem 内存句柄
/// @param new_size 新大小
/// @return 收缩后的大小
ulong LocalShrink(HANDLE mem, uint new_size);

/// 获取本地内存大小
/// @param mem 内存句柄
/// @return 内存大小
ulong LocalSize(HANDLE mem);

/// 本地内存解锁
/// @param mem 内存句柄
/// @return 操作结果
int LocalUnlock(HANDLE mem);

/// 定位XState特性
/// @param Context 上下文
/// @param FeatureId 特性ID
/// @param Length 返回的长度
/// @return 特性指针
PVOID LocateXStateFeature(CONTEXT &Context, uint FeatureId, uint &Length);

/// 字符串连接
/// @param string1 目标字符串
/// @param string2 源字符串
/// @return 连接后的字符串
string lstrcatW(ushort &string1[], const string string2);

/// 字符串比较(不区分大小写)
/// @param string1 字符串1
/// @param string2 字符串2
/// @return 比较结果
int lstrcmpiW(const string string1, const string string2);

/// 字符串比较
/// @param string1 字符串1
/// @param string2 字符串2
/// @return 比较结果
int lstrcmpW(const string string1, const string string2);

/// 字符串复制(带长度限制)
/// @param string1 目标字符串
/// @param string2 源字符串
/// @param max_length 最大长度
/// @return 复制后的字符串
string lstrcpynW(ushort &string1[], const string string2, int max_length);

/// 字符串复制
/// @param string1 目标字符串
/// @param string2 源字符串
/// @return 复制后的字符串
string lstrcpyW(ushort &string1[], const string string2);

/// 获取字符串长度
/// @param str 字符串
/// @return 字符串长度
int lstrlenW(const string str);

/// 映射用户物理页(分散)
/// @param VirtualAddresses 虚拟地址数组
/// @param NumberOfPages 页数
/// @param PageArray 页数组
/// @return 操作结果
int MapUserPhysicalPagesScatter(PVOID &VirtualAddresses[], ulong NumberOfPages, ulong &PageArray[]);

/// 映射文件视图(扩展NUMA)
/// @param file_mapping_object 文件映射对象
/// @param desired_access 访问权限
/// @param file_offset_high 文件偏移高32位
/// @param file_offset_low 文件偏移低32位
/// @param number_of_bytes_to_map 映射字节数
/// @param base_address 基地址
/// @param preferred 首选NUMA节点
/// @return 映射地址
PVOID MapViewOfFileExNuma(HANDLE file_mapping_object, uint desired_access, uint file_offset_high, uint file_offset_low, ulong number_of_bytes_to_map, PVOID base_address, uint preferred);

/// 移动文件(扩展)
/// @param existing_file_name 源文件名
/// @param new_file_name 目标文件名
/// @param flags 标志位
/// @return 操作结果
int MoveFileExW(const string existing_file_name, const string new_file_name, uint flags);

/// 移动文件(事务)
/// @param existing_file_name 源文件名
/// @param new_file_name 目标文件名
/// @param progress_routine 进度回调
/// @param data 回调数据
/// @param flags 标志位
/// @param transaction 事务句柄
/// @return 操作结果
int MoveFileTransactedW(const string existing_file_name, const string new_file_name, PVOID progress_routine, PVOID data, uint flags, HANDLE transaction);

/// 移动文件
/// @param existing_file_name 源文件名
/// @param new_file_name 目标文件名
/// @return 操作结果
int MoveFileW(const string existing_file_name, const string new_file_name);

/// 带进度移动文件
/// @param existing_file_name 源文件名
/// @param new_file_name 目标文件名
/// @param progress_routine 进度回调
/// @param data 回调数据
/// @param flags 标志位
/// @return 操作结果
int MoveFileWithProgressW(const string existing_file_name, const string new_file_name, PVOID progress_routine, PVOID data, uint flags);

/// 乘除运算
/// @param number 数字
/// @param numerator 分子
/// @param denominator 分母
/// @return 计算结果
int MulDiv(int number, int numerator, int denominator);

/// 通过ID打开文件
/// @param volume_hint 卷提示
/// @param file_id 文件ID描述符
/// @param desired_access 访问权限
/// @param share_mode 共享模式
/// @param security_attributes 安全属性
/// @param flags_and_attributes 标志和属性
/// @return 文件句柄
HANDLE OpenFileById(HANDLE volume_hint, FILE_ID_DESCRIPTOR &file_id, uint desired_access, uint share_mode, PVOID security_attributes, uint flags_and_attributes);

/// 清除电源请求
/// @param PowerRequest 电源请求句柄
/// @param RequestType 请求类型
/// @return 操作结果
int PowerClearRequest(HANDLE PowerRequest, POWER_REQUEST_TYPE RequestType);

/// 创建电源请求
/// @param Context 原因上下文
/// @return 电源请求句柄
HANDLE PowerCreateRequest(REASON_CONTEXT &Context);

/// 设置电源请求
/// @param PowerRequest 电源请求句柄
/// @param RequestType 请求类型
/// @return 操作结果
int PowerSetRequest(HANDLE PowerRequest, POWER_REQUEST_TYPE RequestType);

/// 准备磁带
/// @param device 设备句柄
/// @param operation 操作类型
/// @param immediate 立即执行标志
/// @return 操作结果
uint PrepareTape(HANDLE device, uint operation, int immediate);

/// 触发事件
/// @param event 事件句柄
/// @return 操作结果
int PulseEvent(HANDLE event);

/// 清除通信缓冲区
/// @param file 文件句柄
/// @param flags 标志位
/// @return 操作结果
int PurgeComm(HANDLE file, uint flags);

/// 查询激活上下文设置
/// @param flags 标志位
/// @param act_ctx 激活上下文句柄
/// @param name_space 命名空间
/// @param name 名称
/// @param buffer 缓冲区
/// @param buffer_len 缓冲区长度
/// @param written_or_required 写入或需要的长度
/// @return 操作结果
int QueryActCtxSettingsW(uint flags, HANDLE act_ctx, const string name_space, const string name, string buffer, ulong buffer_len, ulong &written_or_required);

/// 查询激活上下文设置(结构体版本)
/// @param flags 标志位
/// @param act_ctx 激活上下文结构
/// @param name_space 命名空间
/// @param name 名称
/// @param buffer 缓冲区
/// @param buffer_len 缓冲区长度
/// @param written_or_required 写入或需要的长度
/// @return 操作结果
int QueryActCtxSettingsW(uint flags, ACTCTXW &act_ctx, const string name_space, const string name, string buffer, ulong buffer_len, ulong &written_or_required);

/// 查询激活上下文
/// @param flags 标志位
/// @param act_ctx 激活上下文句柄
/// @param sub_instance 子实例
/// @param info_class 信息类
/// @param buffer 缓冲区
/// @param buffer_len 缓冲区长度
/// @param written_or_required 写入或需要的长度
/// @return 操作结果
int QueryActCtxW(uint flags, HANDLE act_ctx, PVOID sub_instance, uint info_class, PVOID buffer, ulong buffer_len, ulong &written_or_required);

/// 查询激活上下文(结构体版本)
/// @param flags 标志位
/// @param act_ctx 激活上下文结构
/// @param sub_instance 子实例
/// @param info_class 信息类
/// @param buffer 缓冲区
/// @param buffer_len 缓冲区长度
/// @param written_or_required 写入或需要的长度
/// @return 操作结果
int QueryActCtxW(uint flags, ACTCTXW &act_ctx, PVOID sub_instance, uint info_class, PVOID buffer, ulong buffer_len, ulong &written_or_required);

/// 查询完整进程映像名称
/// @param process 进程句柄
/// @param flags 标志位
/// @param exe_name 可执行文件名
/// @param size 大小
/// @return 操作结果
int QueryFullProcessImageNameW(HANDLE process, uint flags, string exe_name, uint &size);

/// 查询线程性能分析状态
/// @param ThreadHandle 线程句柄
/// @param Enabled 是否启用
/// @return 操作结果
uint QueryThreadProfiling(HANDLE ThreadHandle, uchar &Enabled);

/// 查询UMS线程信息
/// @param UmsThread UMS线程
/// @param UmsThreadInfoClass UMS线程信息类
/// @param UmsThreadInformation UMS线程信息
/// @param UmsThreadInformationLength UMS线程信息长度
/// @param ReturnLength 返回长度
/// @return 操作结果
int QueryUmsThreadInformation(PVOID UmsThread, RTL_UMS_THREAD_INFO_CLASS UmsThreadInfoClass, PVOID UmsThreadInformation, uint UmsThreadInformationLength, uint &ReturnLength);

/// 读取目录变更(扩展)
/// @param directory 目录句柄
/// @param buffer 缓冲区
/// @param buffer_length 缓冲区长度
/// @param watch_subtree 是否监视子树
/// @param notify_filter 通知过滤器
/// @param bytes_returned 返回字节数
/// @param overlapped 重叠结构
/// @param completion_routine 完成回调
/// @param ReadDirectoryNotifyInformationClass 读取目录通知信息类
/// @return 操作结果
int ReadDirectoryChangesExW(HANDLE directory, PVOID buffer, uint buffer_length, int watch_subtree, uint notify_filter, uint &bytes_returned, OVERLAPPED &overlapped, PVOID completion_routine, READ_DIRECTORY_NOTIFY_INFORMATION_CLASS ReadDirectoryNotifyInformationClass);

/// 读取目录变更
/// @param directory 目录句柄
/// @param buffer 缓冲区
/// @param buffer_length 缓冲区长度
/// @param watch_subtree 是否监视子树
/// @param notify_filter 通知过滤器
/// @param bytes_returned 返回字节数
/// @param overlapped 重叠结构
/// @param completion_routine 完成回调
/// @return 操作结果
int ReadDirectoryChangesW(HANDLE directory, PVOID buffer, uint buffer_length, int watch_subtree, uint notify_filter, uint &bytes_returned, OVERLAPPED &overlapped, PVOID completion_routine);

/// 读取线程性能数据
/// @param PerformanceDataHandle 性能数据句柄
/// @param Flags 标志位
/// @param PerformanceData 性能数据
/// @return 操作结果
uint ReadThreadProfilingData(HANDLE PerformanceDataHandle, uint Flags, PERFORMANCE_DATA &PerformanceData);

/// 注册应用程序恢复回调
/// @param recovey_callback 恢复回调
/// @param parameter 参数
/// @param ping_interval ping间隔
/// @param flags 标志位
/// @return 操作结果
int RegisterApplicationRecoveryCallback(PVOID recovey_callback, PVOID parameter, uint ping_interval, uint flags);

/// 注册应用程序重启
/// @param commandline 命令行
/// @param flags 标志位
/// @return 操作结果
int RegisterApplicationRestart(const string commandline, uint flags);

/// 注册等待单对象
/// @param new_wait_object 新等待对象
/// @param object 对象句柄
/// @param Callback 回调函数
/// @param Context 上下文
/// @param milliseconds 毫秒数
/// @param flags 标志位
/// @return 操作结果
int RegisterWaitForSingleObject(HANDLE &new_wait_object, HANDLE object, PVOID Callback, PVOID Context, uint milliseconds, uint flags);

/// 释放激活上下文
/// @param act_ctx 激活上下文句柄
void ReleaseActCtx(HANDLE act_ctx);

/// 释放激活上下文(结构体版本)
/// @param act_ctx 激活上下文结构
void ReleaseActCtx(ACTCTXW &act_ctx);

/// 删除目录(事务)
/// @param path_name 路径名
/// @param transaction 事务句柄
/// @return 操作结果
int RemoveDirectoryTransactedW(const string path_name, HANDLE transaction);

/// 移除安全内存缓存回调
/// @param call_back 回调函数
/// @return 操作结果
int RemoveSecureMemoryCacheCallback(PVOID call_back);

/// 重新打开文件
/// @param original_file 原始文件句柄
/// @param desired_access 访问权限
/// @param share_mode 共享模式
/// @param flags_and_attributes 标志和属性
/// @return 新文件句柄
HANDLE ReOpenFile(HANDLE original_file, uint desired_access, uint share_mode, uint flags_and_attributes);

/// 替换文件
/// @param replaced_file_name 被替换文件名
/// @param replacement_file_name 替换文件名
/// @param backup_file_name 备份文件名
/// @param replace_flags 替换标志
/// @param exclude 排除
/// @param reserved 保留
/// @return 操作结果
int ReplaceFileW(const string replaced_file_name, const string replacement_file_name, const string backup_file_name, uint replace_flags, PVOID exclude, PVOID reserved);

/// 替换分区单元
/// @param TargetPartition 目标分区
/// @param SparePartition 备用分区
/// @param Flags 标志位
/// @return 操作结果
int ReplacePartitionUnit(string TargetPartition, string SparePartition, uint Flags);

/// 请求设备唤醒
/// @param device 设备句柄
/// @return 操作结果
int RequestDeviceWakeup(HANDLE device);

/// 请求唤醒延迟
/// @param latency 延迟时间
/// @return 操作结果
int RequestWakeupLatency(LATENCY_TIME latency);

/// 恢复最后错误代码
/// @param err_code 错误代码
void RestoreLastError(uint err_code);

/// 设置通信中断
/// @param file 文件句柄
/// @return 操作结果
int SetCommBreak(HANDLE file);

/// 设置通信配置
/// @param comm_dev 通信设备
/// @param lpCC 通信配置
/// @param size 大小
/// @return 操作结果
int SetCommConfig(HANDLE comm_dev, COMMCONFIG &lpCC, uint size);

/// 设置通信事件掩码
/// @param file 文件句柄
/// @param evt_mask 事件掩码
/// @return 操作结果
int SetCommMask(HANDLE file, uint evt_mask);

/// 设置通信状态
/// @param file 文件句柄
/// @param lpDCB DCB结构
/// @return 操作结果
int SetCommState(HANDLE file, DCB &lpDCB);

/// 设置通信超时
/// @param file 文件句柄
/// @param comm_timeouts 通信超时
/// @return 操作结果
int SetCommTimeouts(HANDLE file, COMMTIMEOUTS &comm_timeouts);

/// 设置默认通信配置
/// @param name 名称
/// @param lpCC 通信配置
/// @param size 大小
/// @return 操作结果
int SetDefaultCommConfigW(const string name, COMMCONFIG &lpCC, uint size);

/// 设置DLL目录
/// @param path_name 路径名
/// @return 操作结果
int SetDllDirectoryW(const string path_name);

/// 设置文件属性(事务)
/// @param file_name 文件名
/// @param file_attributes 文件属性
/// @param transaction 事务句柄
/// @return 操作结果
int SetFileAttributesTransactedW(const string file_name, uint file_attributes, HANDLE transaction);

/// 设置文件带宽预留
/// @param file 文件句柄
/// @param period_milliseconds 周期毫秒数
/// @param bytes_per_period 每周期字节数
/// @param discardable 可丢弃标志
/// @param transfer_size 传输大小
/// @param num_outstanding_requests 未完成请求数
/// @return 操作结果
int SetFileBandwidthReservation(HANDLE file, uint period_milliseconds, uint bytes_per_period, int discardable, uint &transfer_size, uint &num_outstanding_requests);

/// 设置文件完成通知模式
/// @param FileHandle 文件句柄
/// @param Flags 标志位
/// @return 操作结果
int SetFileCompletionNotificationModes(HANDLE FileHandle, uchar Flags);

/// 设置文件短名称
/// @param file 文件句柄
/// @param short_name 短名称
/// @return 操作结果
int SetFileShortNameW(HANDLE file, const string short_name);

/// 设置固件环境变量(扩展)
/// @param name 名称
/// @param guid GUID
/// @param value 值
/// @param size 大小
/// @param attributes 属性
/// @return 操作结果
int SetFirmwareEnvironmentVariableExW(const string name, const string guid, PVOID value, uint size, uint attributes);

/// 设置固件环境变量
/// @param name 名称
/// @param guid GUID
/// @param value 值
/// @param size 大小
/// @return 操作结果
int SetFirmwareEnvironmentVariableW(const string name, const string guid, PVOID value, uint size);

/// 设置句柄数量
/// @param number 数量
/// @return 操作结果
uint SetHandleCount(uint number);

/// 设置邮件槽信息
/// @param mailslot 邮件槽句柄
/// @param read_timeout 读取超时
/// @return 操作结果
int SetMailslotInfo(HANDLE mailslot, uint read_timeout);

/// 设置消息等待指示器
/// @param msg_indicator 消息指示器句柄
/// @param msg_count 消息计数
/// @return 操作结果
int SetMessageWaitingIndicator(HANDLE msg_indicator, uint msg_count);

/// 设置进程关联掩码
/// @param process 进程句柄
/// @param process_affinity_mask 进程关联掩码
/// @return 操作结果
int SetProcessAffinityMask(HANDLE process, PVOID process_affinity_mask);

/// 设置进程DEP策略
/// @param flags 标志位
/// @return 操作结果
int SetProcessDEPPolicy(uint flags);

/// 设置进程工作集大小
/// @param process 进程句柄
/// @param minimum_working_set_size 最小工作集大小
/// @param maximum_working_set_size 最大工作集大小
/// @return 操作结果
int SetProcessWorkingSetSize(HANDLE process, ulong minimum_working_set_size, ulong maximum_working_set_size);

/// 设置搜索路径模式
/// @param flags 标志位
/// @return 操作结果
int SetSearchPathMode(uint flags);

/// 设置系统电源状态
/// @param suspend 挂起标志
/// @param force 强制标志
/// @return 操作结果
int SetSystemPowerState(int suspend, int force);

/// 设置磁带参数
/// @param device 设备句柄
/// @param operation 操作
/// @param tape_information 磁带信息
/// @return 操作结果
uint SetTapeParameters(HANDLE device, uint operation, PVOID tape_information);

/// 设置磁带位置
/// @param device 设备句柄
/// @param position_method 位置方法
/// @param partition 分区
/// @param offset_low 偏移低32位
/// @param offset_high 偏移高32位
/// @param immediate 立即执行标志
/// @return 操作结果
uint SetTapePosition(HANDLE device, uint position_method, uint partition, uint offset_low, uint offset_high, int immediate);

/// 设置线程关联掩码
/// @param thread 线程句柄
/// @param thread_affinity_mask 线程关联掩码
/// @return 操作结果
PVOID SetThreadAffinityMask(HANDLE thread, PVOID thread_affinity_mask);

/// 设置线程执行状态
/// @param flags 标志位
/// @return 操作结果
uint SetThreadExecutionState(uint flags);

/// 设置定时器队列定时器
/// @param TimerQueue 定时器队列
/// @param Callback 回调函数
/// @param Parameter 参数
/// @param DueTime 到期时间
/// @param Period 周期
/// @param PreferIo 优先IO
/// @return 定时器句柄
HANDLE SetTimerQueueTimer(HANDLE TimerQueue, PVOID Callback, PVOID Parameter, uint DueTime, uint Period, int PreferIo);

/// 设置UMS线程信息
/// @param UmsThread UMS线程
/// @param UmsThreadInfoClass UMS线程信息类
/// @param UmsThreadInformation UMS线程信息
/// @param UmsThreadInformationLength UMS线程信息长度
/// @return 操作结果
int SetUmsThreadInformation(PVOID UmsThread, RTL_UMS_THREAD_INFO_CLASS UmsThreadInfoClass, PVOID UmsThreadInformation, uint UmsThreadInformationLength);

/// 设置通信
/// @param file 文件句柄
/// @param in_queue 输入队列
/// @param out_queue 输出队列
/// @return 操作结果
int SetupComm(HANDLE file, uint in_queue, uint out_queue);

/// 设置卷标
/// @param root_path_name 根路径名
/// @param volume_name 卷名
/// @return 操作结果
int SetVolumeLabelW(const string root_path_name, const string volume_name);

/// 设置卷挂载点
/// @param volume_mount_point 卷挂载点
/// @param volume_name 卷名
/// @return 操作结果
int SetVolumeMountPointW(const string volume_mount_point, const string volume_name);

/// 设置XState特性掩码
/// @param Context 上下文
/// @param FeatureMask 特性掩码
/// @return 操作结果
int SetXStateFeaturesMask(CONTEXT &Context, ulong FeatureMask);

/// 信号对象并等待
/// @param object_to_signal 要信号的对象
/// @param object_to_wait_on 要等待的对象
/// @param milliseconds 毫秒数
/// @param alertable 可警报标志
/// @return 操作结果
uint SignalObjectAndWait(HANDLE object_to_signal, HANDLE object_to_wait_on, uint milliseconds, int alertable);

/// 切换到纤程
/// @param fiber 纤程地址
void SwitchToFiber(PVOID fiber);

/// 传输通信字符
/// @param file 文件句柄
/// @param symbol 字符
/// @return 操作结果
int TransmitCommChar(HANDLE file, char symbol);

/// UMS线程让步
/// @param SchedulerParam 调度器参数
/// @return 操作结果
int UmsThreadYield(PVOID SchedulerParam);

/// 取消注册应用程序恢复回调
/// @return 操作结果
int UnregisterApplicationRecoveryCallback(void);

/// 取消注册应用程序重启
/// @return 操作结果
int UnregisterApplicationRestart(void);

/// 取消注册等待
/// @param WaitHandle 等待句柄
/// @return 操作结果
int UnregisterWait(HANDLE WaitHandle);

/// 更新资源
/// @param update 更新句柄
/// @param type 资源类型
/// @param name 资源名称
/// @param language 语言
/// @param data 数据
/// @param cb 数据大小
/// @return 操作结果
int UpdateResourceW(HANDLE update, const string type, const string name, ushort &language, PVOID data, uint cb);

/// 验证版本信息
/// @param version_information 版本信息
/// @param type_mask 类型掩码
/// @param condition_mask 条件掩码
/// @return 操作结果
int VerifyVersionInfoW(OSVERSIONINFOEXW &version_information, uint type_mask, ulong condition_mask);

/// 等待通信事件
/// @param file 文件句柄
/// @param evt_mask 事件掩码
/// @param overlapped 重叠结构
/// @return 操作结果
int WaitCommEvent(HANDLE file, uint &evt_mask, OVERLAPPED &overlapped);

/// 启用Wow64文件系统重定向
/// @param Wow64FsEnableRedirection 启用重定向标志
/// @return 先前状态
uchar Wow64EnableWow64FsRedirection(uchar Wow64FsEnableRedirection);

/// 获取Wow64线程上下文
/// @param thread 线程句柄
/// @param context 上下文
/// @return 操作结果
int Wow64GetThreadContext(HANDLE thread, CONTEXT &context);

/// 获取Wow64线程选择器条目
/// @param thread 线程句柄
/// @param selector 选择器
/// @param selector_entry 选择器条目
/// @return 操作结果
int Wow64GetThreadSelectorEntry(HANDLE thread, uint selector, LDT_ENTRY &selector_entry);

/// 设置Wow64线程上下文
/// @param thread 线程句柄
/// @param context 上下文
/// @return 操作结果
int Wow64SetThreadContext(HANDLE thread, CONTEXT &context);

/// 挂起Wow64线程
/// @param thread 线程句柄
/// @return 挂起计数
uint Wow64SuspendThread(HANDLE thread);

/// 写入私有配置文件节
/// @param app_name 应用程序名
/// @param str 字符串
/// @param file_name 文件名
/// @return 操作结果
int WritePrivateProfileSectionW(const string app_name, const string str, const string file_name);

/// 写入私有配置文件字符串
/// @param app_name 应用程序名
/// @param key_name 键名
/// @param str 字符串
/// @param file_name 文件名
/// @return 操作结果
int WritePrivateProfileStringW(const string app_name, const string key_name, const string str, const string file_name);

/// 写入私有配置文件结构
/// @param section 节
/// @param key 键
/// @param struct_obj 结构对象
/// @param size_struct 结构大小
/// @param file 文件
/// @return 操作结果
int WritePrivateProfileStructW(const string section, const string key, PVOID struct_obj, uint size_struct, const string file);

/// 写入配置文件节
/// @param app_name 应用程序名
/// @param str 字符串
/// @return 操作结果
int WriteProfileSectionW(const string app_name, const string str);

/// 写入配置文件字符串
/// @param app_name 应用程序名
/// @param key_name 键名
/// @param str 字符串
/// @return 操作结果
int WriteProfileStringW(const string app_name, const string key_name, const string str);

/// 写入磁带标记
/// @param device 设备句柄
/// @param tapemark_type 标记类型
/// @param tapemark_count 标记数量
/// @param immediate 立即执行标志
/// @return 操作结果
uint WriteTapemark(HANDLE device, uint tapemark_type, uint tapemark_count, int immediate);

/// 获取活动控制台会话ID
/// @return 会话ID
uint WTSGetActiveConsoleSessionId(void);

/// 僵尸化激活上下文
/// @param act_ctx 激活上下文句柄
/// @return 操作结果
int ZombifyActCtx(HANDLE act_ctx);

/// 僵尸化激活上下文(结构体版本)
/// @param act_ctx 激活上下文结构
/// @return 操作结果
int ZombifyActCtx(ACTCTXW &act_ctx);
#import

#import "advapi32.dll"
/// 添加条件ACE
/// @param acl ACL
/// @param ace_revision ACE修订版本
/// @param AceFlags ACE标志
/// @param AceType ACE类型
/// @param AccessMask 访问掩码
/// @param sid SID
/// @param ConditionStr 条件字符串
/// @param ReturnLength 返回长度
/// @return 操作结果
int AddConditionalAce(ACL &acl, uint ace_revision, uint AceFlags, uchar AceType, uint AccessMask, SID &sid, string ConditionStr, uint &ReturnLength);

/// 备份事件日志
/// @param event_log 事件日志句柄
/// @param backup_file_name 备份文件名
/// @return 操作结果
int BackupEventLogW(HANDLE event_log, const string backup_file_name);

/// 清除事件日志
/// @param event_log 事件日志句柄
/// @param backup_file_name 备份文件名
/// @return 操作结果
int ClearEventLogW(HANDLE event_log, const string backup_file_name);

/// 关闭加密文件原始访问
/// @param context 上下文
void CloseEncryptedFileRaw(PVOID context);

/// 关闭事件日志
/// @param event_log 事件日志句柄
/// @return 操作结果
int CloseEventLog(HANDLE event_log);

/// 解密文件
/// @param file_name 文件名
/// @param reserved 保留
/// @return 操作结果
int DecryptFileW(const string file_name, uint reserved);

/// 注销事件源
/// @param event_log 事件日志句柄
/// @return 操作结果
int DeregisterEventSource(HANDLE event_log);

/// 加密文件
/// @param file_name 文件名
/// @return 操作结果
int EncryptFileW(const string file_name);

/// 获取文件加密状态
/// @param file_name 文件名
/// @param status 状态
/// @return 操作结果
int FileEncryptionStatusW(const string file_name, uint &status);

/// 获取当前硬件配置文件
/// @param hw_profile_info 硬件配置文件信息
/// @return 操作结果
int GetCurrentHwProfileW(HW_PROFILE_INFOW &hw_profile_info);

/// 获取事件日志信息
/// @param event_log 事件日志句柄
/// @param info_level 信息级别
/// @param buffer 缓冲区
/// @param buf_size 缓冲区大小
/// @param bytes_needed 需要的字节数
/// @return 操作结果
int GetEventLogInformation(HANDLE event_log, uint info_level, PVOID buffer, uint buf_size, uint &bytes_needed);

/// 获取事件日志记录数
/// @param event_log 事件日志句柄
/// @param NumberOfRecords 记录数
/// @return 操作结果
int GetNumberOfEventLogRecords(HANDLE event_log, uint &NumberOfRecords);

/// 获取最旧事件日志记录
/// @param event_log 事件日志句柄
/// @param OldestRecord 最旧记录
/// @return 操作结果
int GetOldestEventLogRecord(HANDLE event_log, uint &OldestRecord);

/// 获取用户名
/// @param buffer 缓冲区
/// @param buffer_len 缓冲区长度
/// @return 操作结果
int GetUserNameW(string buffer, uint &buffer_len);

/// 检查文本是否为Unicode
/// @param lpv 文本指针
/// @param size 大小
/// @param result 结果
/// @return 操作结果
int IsTextUnicode(PVOID lpv, int size, int &result);

/// 检查令牌是否不受信任
/// @param TokenHandle 令牌句柄
/// @return 是否不受信任
int IsTokenUntrusted(HANDLE TokenHandle);

/// 登录用户(扩展)
/// @param username 用户名
/// @param domain 域
/// @param password 密码
/// @param logon_type 登录类型
/// @param logon_provider 登录提供者
/// @param token 返回的令牌
/// @param logon_sid 登录SID
/// @param profile_buffer 配置文件缓冲区
/// @param profile_length 配置文件长度
/// @param quota_limits 配额限制
/// @return 操作结果
int LogonUserExW(const string username, const string domain, const string password, uint logon_type, uint logon_provider, HANDLE &token, PVOID &logon_sid, PVOID &profile_buffer, uint &profile_length, QUOTA_LIMITS &quota_limits);

/// 登录用户
/// @param username 用户名
/// @param domain 域
/// @param password 密码
/// @param logon_type 登录类型
/// @param logon_provider 登录提供者
/// @param token 返回的令牌
/// @return 操作结果
int LogonUserW(const string username, const string domain, const string password, uint logon_type, uint logon_provider, HANDLE &token);

/// 查找帐户名
/// @param system_name 系统名
/// @param account_name 帐户名
/// @param Sid SID
/// @param sid SID大小
/// @param ReferencedDomainName 引用域名
/// @param referenced_domain_name 引用域名大小
/// @param use 使用类型
/// @return 操作结果
int LookupAccountNameW(const string system_name, const string account_name, SID &Sid, uint &sid, string ReferencedDomainName, uint &referenced_domain_name, SID_NAME_USE &use);

/// 查找帐户SID
/// @param system_name 系统名
/// @param Sid SID
/// @param Name 名称
/// @param name 名称大小
/// @param ReferencedDomainName 引用域名
/// @param referenced_domain_name 引用域名大小
/// @param use 使用类型
/// @return 操作结果
int LookupAccountSidW(const string system_name, SID &Sid, string Name, uint &name, string ReferencedDomainName, uint &referenced_domain_name, SID_NAME_USE &use);

/// 查找权限显示名称
/// @param system_name 系统名
/// @param name 名称
/// @param display_name 显示名称
/// @param display_name_len 显示名称长度
/// @param language_id 语言ID
/// @return 操作结果
int LookupPrivilegeDisplayNameW(const string system_name, const string name, string display_name, uint &display_name_len, uint &language_id);

/// 查找权限名称
/// @param system_name 系统名
/// @param luid LUID
/// @param name 名称
/// @param name_len 名称长度
/// @return 操作结果
int LookupPrivilegeNameW(const string system_name, LUID &luid, string name, uint &name_len);

/// 查找权限值
/// @param system_name 系统名
/// @param name 名称
/// @param luid LUID
/// @return 操作结果
int LookupPrivilegeValueW(const string system_name, const string name, LUID &luid);

/// 通知变更事件日志
/// @param event_log 事件日志句柄
/// @param event 事件句柄
/// @return 操作结果
int NotifyChangeEventLog(HANDLE event_log, HANDLE event);

/// 打开备份事件日志
/// @param lpUNCServerName UNC服务器名
/// @param file_name 文件名
/// @return 事件日志句柄
HANDLE OpenBackupEventLogW(const string lpUNCServerName, const string file_name);

/// 打开加密文件原始访问
/// @param file_name 文件名
/// @param flags 标志位
/// @param context 上下文
/// @return 操作结果
uint OpenEncryptedFileRawW(const string file_name, uint flags, PVOID &context);

/// 打开事件日志
/// @param lpUNCServerName UNC服务器名
/// @param source_name 源名
/// @return 事件日志句柄
HANDLE OpenEventLogW(const string lpUNCServerName, const string source_name);

/// 操作结束
/// @param OperationEndParams 操作结束参数
/// @return 操作结果
int OperationEnd(OPERATION_END_PARAMETERS &OperationEndParams);

/// 操作开始
/// @param OperationStartParams 操作开始参数
/// @return 操作结果
int OperationStart(OPERATION_START_PARAMETERS &OperationStartParams);

/// 读取加密文件原始数据
/// @param export_callback 导出回调
/// @param callback_context 回调上下文
/// @param context 上下文
/// @return 操作结果
uint ReadEncryptedFileRaw(PVOID export_callback, PVOID callback_context, PVOID context);

/// 读取事件日志
/// @param event_log 事件日志句柄
/// @param read_flags 读取标志
/// @param record_offset 记录偏移
/// @param buffer 缓冲区
/// @param number_of_bytes_to_read 要读取的字节数
/// @param bytes_read 已读取字节数
/// @param min_number_of_bytes_needed 需要的最小字节数
/// @return 操作结果
int ReadEventLogW(HANDLE event_log, uint read_flags, uint record_offset, PVOID buffer, uint number_of_bytes_to_read, uint &bytes_read, uint &min_number_of_bytes_needed);

/// 注册事件源
/// @param lpUNCServerName UNC服务器名
/// @param source_name 源名
/// @return 事件日志句柄
HANDLE RegisterEventSourceW(const string lpUNCServerName, const string source_name);

/// 报告事件
/// @param event_log 事件日志句柄
/// @param type 类型
/// @param category 类别
/// @param dwEventID 事件ID
/// @param user_sid 用户SID
/// @param num_strings 字符串数
/// @param data_size 数据大小
/// @param strings 字符串数组
/// @param raw_data 原始数据
/// @return 操作结果
int ReportEventW(HANDLE event_log, ushort &type, ushort &category, uint dwEventID, SID &user_sid, ushort &num_strings, uint data_size, const string &strings[], PVOID raw_data);

/// 写入加密文件原始数据
/// @param import_callback 导入回调
/// @param callback_context 回调上下文
/// @param context 上下文
/// @return 操作结果
uint WriteEncryptedFileRaw(PVOID import_callback, PVOID callback_context, PVOID context);
#import
//+------------------------------------------------------------------+